const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');
const DatabaseManager = require('../src/database/database');
const FileManager = require('../src/utils/fileManager');
const UserService = require('../src/services/userService');
const JournalPaperService = require('../src/services/journalPaperService');

const isDev = (() => {
  // 检查应用是否打包（Electron 自带属性）:cite[6]
  if (require('electron').app) {
    return !require('electron').app.isPackaged;
  }
  // 默认返回 false，即生产环境
  return false;
})();

let mainWindow;
let dbManager;
let fileManager;
let userService;
let journalPaperService;
let isIPCSetup = false; // 标记 IPC 是否已设置
let currentUserId = null; // 当前登录的用户ID

function createWindow() {
  // 初始化数据库，文件管理器（只初始化一次）
  if (!dbManager) {
    dbManager = new DatabaseManager();
  }
  if (!fileManager) {
    fileManager = new FileManager();
  }
  if (!userService) {
    // 传入已存在的数据库管理器实例，避免重复初始化
    userService = new UserService(dbManager);
  }
  if (!journalPaperService) {
    // 传入已存在的数据库管理器实例，避免重复初始化
    journalPaperService = new JournalPaperService(dbManager);
  }
  // 创建浏览器窗口
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    frame: false, // 完全移除标题栏和菜单栏
    title: '个人成果管理软件', // 设置窗口标题
    icon: path.join(__dirname, 'icons/app-icon.png'), // 设置窗口图标
    show: false, // 初始隐藏窗口，等待页面加载完成
    backgroundColor: '#f5f5f5', // 设置背景色，减少闪白效果
    webPreferences: {
      nodeIntegration: false,
      enableRemoteModule: false,
      contextIsolation: true,
      preload: path.join(__dirname, 'preload.js')
    }
  });

  // 开发环境下自动打开开发者工具
  if (isDev) {
    mainWindow.loadURL('http://localhost:3000');
    // 开发环境下自动打开开发者工具
    mainWindow.webContents.openDevTools();
  }else{
    mainWindow.loadFile(path.join(__dirname, '../build/index.html'));
  }
  
  // 添加快捷键打开/关闭开发者工具（Ctrl+Shift+I 或 F12）
  mainWindow.webContents.on('before-input-event', (event, input) => {
    if (input.control && input.shift && input.key.toLowerCase() === 'i') {
      if (mainWindow.webContents.isDevToolsOpened()) {
        mainWindow.webContents.closeDevTools();
      } else {
        mainWindow.webContents.openDevTools();
      }
    } else if (input.key === 'F12') {
      if (mainWindow.webContents.isDevToolsOpened()) {
        mainWindow.webContents.closeDevTools();
      } else {
        mainWindow.webContents.openDevTools();
      }
    }
  });

  // 监听页面加载完成事件
  mainWindow.webContents.once('did-finish-load', () => {
    // 页面加载完成，但还需要等待React组件完全渲染
    console.log('页面加载完成，等待React组件渲染...');
  });

  // 监听DOM内容加载完成
  mainWindow.webContents.once('dom-content-loaded', () => {
    console.log('DOM内容加载完成');
  });

  // 控制渲染进程中 window.open 打开的窗口：设为模态子窗口且隐藏菜单栏
  mainWindow.webContents.setWindowOpenHandler(({ url, features, disposition }) => {
    return {
      action: 'allow',
      overrideBrowserWindowOptions: {
        parent: mainWindow,
        modal: true,
        width: 1200,
        height: 800,
        frame: true, // 使用系统标题栏，保留最小化/最大化/关闭
        minimizable: true,
        maximizable: true,
        closable: true,
        autoHideMenuBar: true,
        title: '文件预览',
        icon: path.join(__dirname, 'icons/app-icon.png'),
        webPreferences: {
          contextIsolation: true
        }
      }
    };
  });

  mainWindow.on('closed', () => {
    mainWindow = null;
  });

  // 设置窗口控制API（只设置一次）
  if (!isIPCSetup) {
    setupWindowControls();
    setupIPC();
    isIPCSetup = true;
  }
}

function setupIPC() {
  // 用户登录相关
  ipcMain.handle('user:validate-login', async (event, username, password) => {
    try {
      const user = await userService.validateLogin(username, password);
      if (user) {
        // 保存当前登录的用户ID
        currentUserId = user.id;
      }
      return { success: !!user, user: user || null };
    } catch (error) {
      console.error('登录验证失败:', error);
      return { success: false, user: null, error: error.message };
    }
  });

  // 获取当前登录用户信息
  ipcMain.handle('user:get-current-user', async (event) => {
    try {
      if (!currentUserId) {
        return { success: false, user: null, error: '用户未登录' };
      }
      const user = await userService.getUserById(currentUserId);
      if (!user) {
        return { success: false, user: null, error: '用户不存在' };
      }
      // 排除密码字段
      const { password: _, ...userInfo } = user;
      return { success: true, user: userInfo };
    } catch (error) {
      console.error('获取当前用户信息失败:', error);
      return { success: false, user: null, error: error.message };
    }
  });

  // 期刊论文相关
  ipcMain.handle('db:get-journal-papers', async (event, conditions = {}, pagination = null) => {
    try {
      // 自动添加当前用户ID过滤条件
      if (!currentUserId) {
        return { success: false, data: [], total: 0, error: '用户未登录' };
      }
      const filtersWithUid = { ...conditions, uid: currentUserId };
      const result = await journalPaperService.getAllPapers(filtersWithUid, pagination);
      return { success: true, data: result.papers, total: result.total };
    } catch (error) {
      console.error('查询期刊论文失败:', error);
      return { success: false, data: [], total: 0, error: error.message };
    }
  });

  ipcMain.handle('db:get-journal-paper-by-id', async (event, id) => {
    try {
      if (!currentUserId) {
        return { success: false, data: null, error: '用户未登录' };
      }
      const paper = await journalPaperService.getPaperById(id);
      // 验证是否属于当前用户
      if (!paper || paper.uid !== currentUserId) {
        return { success: false, data: null, error: '无权访问该记录' };
      }
      return { success: true, data: paper };
    } catch (error) {
      console.error('获取期刊论文失败:', error);
      return { success: false, data: null, error: error.message };
    }
  });

  ipcMain.handle('db:create-journal-paper', async (event, data) => {
    try {
      if (!currentUserId) {
        return { success: false, error: '用户未登录' };
      }
      // 自动设置 uid 为当前用户ID
      const dataWithUid = { ...data, uid: currentUserId };
      const id = await journalPaperService.createPaper(dataWithUid);
      return { success: true, id: id, data: dataWithUid };
    } catch (error) {
      console.error('创建期刊论文失败:', error);
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('db:update-journal-paper', async (event, id, data) => {
    try {
      if (!currentUserId) {
        return { success: false, error: '用户未登录' };
      }
      // 先验证记录是否属于当前用户
      const paper = await journalPaperService.getPaperById(id);
      if (!paper || paper.uid !== currentUserId) {
        return { success: false, error: '无权更新该记录' };
      }
      // 更新数据时，移除 uid 字段（不允许更改 uid）
      const { uid, ...updateData } = data;
      const changes = await journalPaperService.updatePaper(id, updateData);
      return { success: true, changes: changes };
    } catch (error) {
      console.error('更新期刊论文失败:', error);
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('db:delete-journal-paper', async (event, id) => {
    try {
      if (!currentUserId) {
        return { success: false, error: '用户未登录' };
      }
      // 先验证记录是否属于当前用户
      const paper = await journalPaperService.getPaperById(id);
      if (!paper || paper.uid !== currentUserId) {
        return { success: false, error: '无权删除该记录' };
      }
      // 先删除文件文件夹（如果存在）
      if (currentUserId && fileManager) {
        try {
          await fileManager.deleteRecordFiles(currentUserId, 'journal', id);
        } catch (fileError) {
          // 如果文件夹删除失败（可能文件夹不存在），记录错误但继续删除数据库记录
          console.warn('删除记录文件夹失败，继续删除数据库记录:', fileError.message);
        }
      }
      
      // 删除数据库记录
      const changes = await journalPaperService.deletePaper(id);
      return { success: true, changes: changes };
    } catch (error) {
      console.error('删除期刊论文失败:', error);
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('db:search-journal-papers', async (event, keyword) => {
    try {
      const papers = await journalPaperService.searchPapers(keyword);
      return { success: true, data: papers };
    } catch (error) {
      console.error('搜索期刊论文失败:', error);
      return { success: false, data: [], error: error.message };
    }
  });

  ipcMain.handle('db:get-journal-paper-stats', async (event) => {
    try {
      const stats = await journalPaperService.getPaperStatistics();
      return { success: true, data: stats };
    } catch (error) {
      console.error('获取统计信息失败:', error);
      return { success: false, data: null, error: error.message };
    }
  });

  // 文件相关
  ipcMain.handle('file:save', async (event, fileData, recordType, recordId, uploadAreaKey) => {
    try {
      if (!currentUserId) {
        return { success: false, error: '用户未登录' };
      }
      
      // 将数组转换回 Buffer（在 Node.js 中 Buffer 是全局的）
      // fileData.buffer 是从渲染进程传来的数组，需要转换为 Buffer
      const fileDataWithBuffer = {
        ...fileData,
        buffer: Buffer.from(fileData.buffer)
      };
      
      const fileInfo = await fileManager.saveFile(fileDataWithBuffer, currentUserId, recordType, recordId, uploadAreaKey);
      
      // 只返回文件名，不返回完整路径（数据库只存储文件名）
      return { 
        success: true, 
        fileName: fileInfo.fileName,
        originalName: fileInfo.originalName,
        fileSize: fileInfo.fileSize,
        fileType: fileInfo.fileType
      };
    } catch (error) {
      console.error('保存文件失败:', error);
      return { success: false, error: error.message };
    }
  });

  // 获取文件完整路径（根据文件名、记录类型、记录ID）
  ipcMain.handle('file:get-path', async (event, recordType, recordId, fileName) => {
    if (!currentUserId) {
      throw new Error('用户未登录');
    }
    return fileManager.getFilePath(currentUserId, recordType, recordId, fileName);
  });

  ipcMain.handle('file:delete', async (event, fileId) => {
    // 注意：如果将来需要文件表，可以在这里实现
    // 目前文件路径直接保存在 journal_paper_info 表中，删除通过删除记录或更新记录实现
    return { success: false, error: '文件删除功能需要文件表支持' };
  });

  // 删除文件（通过文件名、记录类型、记录ID）
  ipcMain.handle('file:delete-by-name', async (event, recordType, recordId, fileName) => {
    try {
      if (!currentUserId) {
        return { success: false, error: '用户未登录' };
      }
      await fileManager.deleteFile(currentUserId, recordType, recordId, fileName);
      return { success: true };
    } catch (error) {
      console.error('删除文件失败:', error);
      return { success: false, error: error.message };
    }
  });

  // 移动文件（从临时目录移动到记录目录）
  ipcMain.handle('file:move', async (event, oldFilePath, newRecordType, newRecordId) => {
    try {
      if (!currentUserId) {
        return { success: false, error: '用户未登录' };
      }
      const result = await fileManager.moveFile(oldFilePath, currentUserId, newRecordType, newRecordId);
      // 只返回文件名，不返回完整路径
      return { 
        success: true, 
        fileName: result.fileName
      };
    } catch (error) {
      console.error('移动文件失败:', error);
      return { success: false, error: error.message };
    }
  });

  // 获取记录的文件列表（如果将来需要文件表，可以在这里实现）
  // 目前文件路径直接保存在 journal_paper_info 表中，可以通过查询记录获取
  ipcMain.handle('db:get-files', async (event, recordId, recordType) => {
    // 暂时返回空数组，因为文件表不存在
    return [];
  });

  // 保存文件到持久化目录（已存在，无需修改）

  // 读取文件并返回 Blob 数据（根据文件名、记录类型、记录ID）
  ipcMain.handle('file:read-blob', async (event, recordType, recordId, fileName) => {
    try {
      if (!currentUserId) {
        throw new Error('用户未登录');
      }
      
      const fs = require('fs');
      const path = require('path');
      
      // 根据文件名、用户ID、记录类型、记录ID构建完整路径
      const filePath = fileManager.getFilePath(currentUserId, recordType, recordId, fileName);
      
      // 读取文件
      const fileBuffer = fs.readFileSync(filePath);
      
      // 获取文件扩展名以确定 MIME 类型
      const ext = path.extname(filePath).toLowerCase();
      const mimeTypes = {
        '.pdf': 'application/pdf',
        '.doc': 'application/msword',
        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
        '.xls': 'application/vnd.ms-excel',
        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
        '.ppt': 'application/vnd.ms-powerpoint',
        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
        '.jpg': 'image/jpeg',
        '.jpeg': 'image/jpeg',
        '.png': 'image/png',
        '.gif': 'image/gif',
        '.zip': 'application/zip',
        '.rar': 'application/x-rar-compressed',
        '.txt': 'text/plain',
        '.csv': 'text/csv'
      };
      
      const mimeType = mimeTypes[ext] || 'application/octet-stream';
      
      // 返回文件数据（Buffer）和元信息
      return {
        data: Array.from(fileBuffer), // 转换为数组以便通过 IPC 传输
        mimeType: mimeType,
        size: fileBuffer.length,
        fileName: path.basename(filePath)
      };
    } catch (error) {
      console.error('读取文件失败:', error);
      throw error;
    }
  });
}

// 设置窗口控制功能
function setupWindowControls() {
  // 最小化窗口
  ipcMain.handle('minimize-window', () => {
    if (mainWindow) {
      mainWindow.minimize();
    }
  });

  // 最大化/还原窗口
  ipcMain.handle('maximize-window', () => {
    if (mainWindow) {
      if (mainWindow.isMaximized()) {
        mainWindow.unmaximize();
      } else {
        mainWindow.maximize();
      }
    }
  });

  // 关闭窗口
  ipcMain.handle('close-window', () => {
    if (mainWindow) {
      mainWindow.close();
    }
  });

  // 页面加载完成，显示窗口
  ipcMain.handle('page-loaded', () => {
    if (mainWindow) {
      // 先设置窗口透明度为0，然后显示窗口
      mainWindow.setOpacity(0);
      mainWindow.show();
      
      // 淡入效果
      let opacity = 0;
      const fadeIn = setInterval(() => {
        opacity += 0.1;
        mainWindow.setOpacity(opacity);
        
        if (opacity >= 1) {
          clearInterval(fadeIn);
          mainWindow.setOpacity(1); // 确保最终透明度为1
        }
      }, 16); // 约60fps的淡入效果
    }
  });

}


// 统一移除新建窗口的菜单栏（确保没有 File/Edit/View... 菜单）
app.on('browser-window-created', (event, window) => {
  if (window && window.removeMenu) {
    window.removeMenu();
  }
});

app.whenReady().then(createWindow);

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

app.on('activate', () => {
  if (BrowserWindow.getAllWindows().length === 0) {
    createWindow();
  }
});